package com.ly.talent.service.impl;

import java.util.List;
import com.ly.common.utils.DateUtils;
import com.ly.common.utils.StringUtils;
import com.ly.talent.domain.TalentDetail;
import com.ly.talent.mapper.TalentDetailMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ly.talent.mapper.TalentBaseInfoMapper;
import com.ly.talent.domain.TalentBaseInfo;
import com.ly.talent.service.ITalentBaseInfoService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 人才引进基本信息Service业务层处理
 * 
 * @author sfli
 * @date 2021-02-01
 */
@Service
public class TalentBaseInfoServiceImpl implements ITalentBaseInfoService 
{
    @Autowired
    private TalentBaseInfoMapper talentBaseInfoMapper;
    @Autowired
    private TalentDetailMapper   talentDetailMapper;

    /**
     * 查询人才引进基本信息
     * 
     * @param talentBaseInfoId 人才引进基本信息ID
     * @return 人才引进基本信息
     */
    @Override
    public TalentBaseInfo selectTalentBaseInfoById(Long talentBaseInfoId)
    {
        TalentBaseInfo baseInfo = talentBaseInfoMapper.selectTalentBaseInfoById(talentBaseInfoId);
        baseInfo.setTalentDetail(talentDetailMapper.selectTalentDetailByBaseInfoId(baseInfo.getTalentBaseInfoId()));
        return baseInfo;
    }

    /**
     * 查询人才引进基本信息
     *
     * @param openId 人才引进基本信息ID
     * @return 人才引进基本信息
     */
    @Override
    public TalentBaseInfo selectTalentByOpenId(String openId)
    {
        TalentBaseInfo baseInfo = talentBaseInfoMapper.selectTalentByOpenId(openId);
        if(baseInfo!=null){
            baseInfo.setTalentDetail(talentDetailMapper.selectTalentDetailByBaseInfoId(baseInfo.getTalentBaseInfoId()));
        }
        return baseInfo;
    }

    /**
     * 查询人才引进基本信息列表
     * 
     * @param talentBaseInfo 人才引进基本信息
     * @return 人才引进基本信息
     */
    @Override
    public List<TalentBaseInfo> selectTalentBaseInfoList(TalentBaseInfo talentBaseInfo)
    {
        return talentBaseInfoMapper.selectTalentBaseInfoList(talentBaseInfo);
    }

    /**
     * 新增人才引进基本信息
     * 
     * @param talentBaseInfo 人才引进基本信息
     * @return 结果
     */
    @Override
    @Transactional
    public int insertTalentBaseInfo(TalentBaseInfo talentBaseInfo)
    {
        talentBaseInfo.setCreateTime(DateUtils.getNowDate());
        talentBaseInfo = checkApply(talentBaseInfo);
        talentBaseInfoMapper.insertTalentBaseInfo(talentBaseInfo);
        TalentDetail t = talentBaseInfo.getTalentDetail();
        t.setTalentBaseInfoId(talentBaseInfo.getTalentBaseInfoId());
        return  talentDetailMapper.insertTalentDetail(t);
    }

    /**
     * 修改人才引进基本信息
     * 
     * @param talentBaseInfo 人才引进基本信息
     * @return 结果
     */
    @Override
    public int updateTalentBaseInfo(TalentBaseInfo talentBaseInfo)
    {
        talentBaseInfo.setUpdateTime(DateUtils.getNowDate());
        talentBaseInfo = checkApply(talentBaseInfo);
        talentBaseInfoMapper.updateTalentBaseInfo(talentBaseInfo);
        TalentDetail t = talentBaseInfo.getTalentDetail();
        t.setTalentBaseInfoId(talentBaseInfo.getTalentBaseInfoId());
        return  talentDetailMapper.updateTalentDetail(t);
    }

    /**
     * 批量删除人才引进基本信息
     * 
     * @param talentBaseInfoIds 需要删除的人才引进基本信息ID
     * @return 结果
     */
    @Override
    public int deleteTalentBaseInfoByIds(Long[] talentBaseInfoIds)
    {
        return talentBaseInfoMapper.deleteTalentBaseInfoByIds(talentBaseInfoIds);
    }

    /**
     * 删除人才引进基本信息信息
     * 
     * @param talentBaseInfoId 人才引进基本信息ID
     * @return 结果
     */
    @Override
    public int deleteTalentBaseInfoById(Long talentBaseInfoId)
    {
        return talentBaseInfoMapper.deleteTalentBaseInfoById(talentBaseInfoId);
    }

    /**
     * 校验申请人资深是否合格，有一项合格及为合格
     * @param talentBaseInfo
     * @return
     */
    public TalentBaseInfo checkApply(TalentBaseInfo talentBaseInfo){
        /**
         * 如果已经校验过结果则不需要再次进行校验
         */
        if(StringUtils.isNotEmpty(talentBaseInfo.getResult())){
            return talentBaseInfo;
        }
        TalentDetail talentDetail = talentBaseInfo.getTalentDetail();
        /**
         * 默认是不合格，只要符合一项则为合格
         */
        String result="2";
        try{
            if(checkL(talentBaseInfo)){
                result = "1";
                talentDetail.setlResult("1");
            }else{
                talentDetail.setlResult("2");
            }

            if(checkU(talentBaseInfo)){
                result = "1";
                talentDetail.setuResult("1");
            }else{
                talentDetail.setuResult("2");
            }

            if(checkT(talentBaseInfo)){
                result = "1";
                talentDetail.setuResult("1");
            }else{
                talentDetail.setuResult("2");
            }

            if("Y".equals(talentDetail.getaIs())){
                if(checkA(talentDetail)){
                    talentDetail.setaResult("1");
                    result = "1";
                }else{
                    talentDetail.setaResult("2");
                }
            }
            if("Y".equals(talentDetail.getbIs())){
                /**
                 * 需要人工审核的直接设置为需要人工审核，如果有其他项合格了，则不需要再进行人工审核
                 */
                if(StringUtils.isEmpty(talentDetail.getbResult())){
                    if("2".equals(result)){
                        result = "3";
                    }
                    talentDetail.setbResult("3");
                }else{
                    result =  talentDetail.getbResult();
                }
            }
            if("Y".equals(talentDetail.getcIs())){
                int r = checkC(talentBaseInfo);
                if(r == 1){
                    result = "1";
                    talentDetail.setcResult("1");
                }else if(r == 2){
                    talentDetail.setcResult("2");
                }else{
                    if(StringUtils.isEmpty(talentDetail.getcResult())){
                        if("2".equals(result)){
                            result = "3";
                        }
                        talentDetail.setcResult("3");
                    }else{
                        result =  talentDetail.getcResult();
                    }
                }
            }
            if("Y".equals(talentDetail.getdIs())){
                if(checkD(talentDetail)){
                    result = "1";
                    talentDetail.setdResult("1");
                }else{
                    talentDetail.setdResult("2");
                }
            }
            if("Y".equals(talentDetail.geteIs())){
                if(StringUtils.isEmpty(talentDetail.geteResult())){
                    if("2".equals(result)){
                        result = "3";
                    }
                    talentDetail.seteResult("3");
                }else{
                    result =  talentDetail.geteResult();
                }
            }
            if("Y".equals(talentDetail.getfIs())){
                if(checkF(talentDetail)){
                    result = "1";
                    talentDetail.setfResult("1");
                }else{
                    talentDetail.setfResult("2");
                }
            }
            if("Y".equals(talentDetail.getgIs())){
                int r = checkG(talentDetail);
                if(r == 1){
                    result = "1";
                    talentDetail.setgResult("1");
                }else if(r == 2){
                    talentDetail.setgResult("2");
                }else{
                    if(StringUtils.isEmpty(talentDetail.getgResult())){
                        if("2".equals(result)){
                            result = "3";
                        }
                        talentDetail.setgResult("3");
                    }else{
                        result =  talentDetail.getgResult();
                    }
                }
            }
            if("Y".equals(talentDetail.gethIs())){
                if(checkH(talentBaseInfo)){
                    result = "1";
                    talentDetail.sethResult("1");
                }else{
                    talentDetail.sethResult("2");
                }
            }
            if("Y".equals(talentDetail.getiIs())){
                if(StringUtils.isEmpty(talentDetail.getiResult())){
                    if("2".equals(result)){
                        result = "3";
                    }
                    talentDetail.setiResult("3");
                }else{
                    result =  talentDetail.getiResult();
                }
            }
            if("Y".equals(talentDetail.getjIs())){
                int r = checkJ(talentBaseInfo);
                if(r == 1){
                    result = "1";
                    talentDetail.setjResult("1");
                }else if(r == 2){
                    talentDetail.setjResult("2");
                }else{
                    if(StringUtils.isEmpty(talentDetail.getjResult())){
                        if("2".equals(result)){
                            result = "3";
                        }
                        talentDetail.setjResult("3");
                    }else{
                        result =  talentDetail.getjResult();
                    }
                }
            }
            if("Y".equals(talentDetail.getkIs())){
                if(checkK(talentBaseInfo)){
                    result = "1";
                    talentDetail.setkResult("1");
                }else{
                    talentDetail.setkResult("2");
                }
            }

            if("Y".equals(talentDetail.getmIs())){
                if(checkM(talentBaseInfo)){
                    result = "1";
                    talentDetail.setmResult("1");
                }else{
                    talentDetail.setmResult("2");
                }
            }
            if("Y".equals(talentDetail.getnIs())){
                if(checkN(talentBaseInfo)){
                    result = "1";
                    talentDetail.setnResult("1");
                }else{
                    talentDetail.setnResult("2");
                }
            }
            if("Y".equals(talentDetail.getoIs())){
                if(checkO(talentDetail)){
                    result = "1";
                    talentDetail.setoResult("1");
                }else{
                    talentDetail.setoResult("2");
                }
            }
            if("Y".equals(talentDetail.getpIs())){
                if(checkP(talentDetail)){
                    result = "1";
                    talentDetail.setpResult("1");
                }else{
                    talentDetail.setpResult("2");
                }
            }
            if("Y".equals(talentDetail.getqIs())){
                if(StringUtils.isEmpty(talentDetail.getqResult())){
                    if("2".equals(result)){
                        result = "3";
                    }
                    talentDetail.setqResult("3");
                }else{
                    result =  talentDetail.getqResult();
                }
            }
            if("Y".equals(talentDetail.getrIs())){
                int r = checkR(talentDetail);
                if(r == 1){
                    result = "1";
                    talentDetail.setrResult("1");
                }else if(r == 2){
                    talentDetail.setrResult("2");
                }else{
                    if(StringUtils.isEmpty(talentDetail.getrResult())){
                        if("2".equals(result)){
                            result = "3";
                        }
                        talentDetail.setrResult("3");
                    }else{
                        result =  talentDetail.getrResult();
                    }
                }
            }
            if("Y".equals(talentDetail.gettIs())){
                if(StringUtils.isEmpty(talentDetail.gettResult())){
                    if("2".equals(result)){
                        result = "3";
                    }
                    talentDetail.settResult("3");
                }else{
                    result =  talentDetail.gettResult();
                }
            }

            if("Y".equals(talentDetail.getvIs())){
                if(StringUtils.isEmpty(talentDetail.getvResult())){
                    if("2".equals(result)){
                        result = "3";
                    }
                    talentDetail.setvResult("3");
                }else{
                    result =  talentDetail.getvResult();
                }
            }
            if("Y".equals(talentDetail.getwIs())){
                if(checkW(talentDetail)){
                    result = "1";
                    talentDetail.setwResult("1");
                }else{
                    talentDetail.setwResult("2");
                }
            }
            if("Y".equals(talentDetail.getxIs())){
                if(StringUtils.isEmpty(talentDetail.getxResult())){
                    if("2".equals(result)){
                        result = "3";
                    }
                    talentDetail.setxResult("3");
                }else{
                    result =  talentDetail.getxResult();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        talentBaseInfo.setTalentDetail(talentDetail);
        talentBaseInfo.setResult(result);
        return talentBaseInfo;
    }
    public Boolean checkA(TalentDetail talentDetail){
        /*if(StringUtils.isEmpty(talentDetail.getaName())||StringUtils.isEmpty(talentDetail.getaNameT())){
            return false;
        }*/
        try{
            if("1".equals(talentDetail.getaAwards())){
                return true;
            }else  if("2".equals(talentDetail.getaAwards()) && talentDetail.getaNumber() <= 2){
                return true;
            }else  if("3".equals(talentDetail.getaAwards()) && talentDetail.getaNumber() <= 2){
                return true;
            }else  if("4".equals(talentDetail.getaAwards()) && talentDetail.getaNumber() <= 2){
                return true;
            }else if("5".equals(talentDetail.getaAwards()) && talentDetail.getaNumber() == 1){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;

    }

    /**
     * 审核规则：（此项目需结合人工审核）
     * 1.“负责人姓名”与“拟引进人才姓名”一致的，合格。
     * 2.平台名称中包括“重点实验室”“企业技术中心”“工程技术中心”“企业研发机构”“研究院”“研究所”等名称为合格；
     * 3.填报项目为国家级、市级机构派发的项目为合格。
     *
     * 本项存在人工审核项目，首先显示Ⅲ。人工审核后，1、2、3项均合格的，本项合格，显示Ⅰ。
     * @param talentBaseInfo
     * @return
     */
    /*public Boolean checkB(TalentBaseInfo talentBaseInfo){
        return true;
    }*/

    /**
     * 审核规则：
     * 1.市级财政贡献达到5000万元及以上，即合格。
     * 2.申请人是否为公司任职满3年正职的一栏，勾选“是”的，合格；
     * 3.姓名与表1“拟引进人才姓名”一致的，合格；
     * 4.职务选择法定代表人、总经理、总裁、董事长的，合格；选择其他的，不合格。
     * 5.任职年月填写完整的，合格。
     *
     * 以上1、2、3、4、5项均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * 4为其他正职 测显示3
     * @param talentBaseInfo
     * @return 1合格 2不合格 3人工审核
     */
    public int checkC(TalentBaseInfo talentBaseInfo){
        TalentDetail talentDetail = talentBaseInfo.getTalentDetail();
        /**
         * 任职时间为空或者职务为非正职 不合格
         */
        try{
            if(StringUtils.isEmpty(talentDetail.getcPostDate())||"6".equals(talentDetail.getcPost())){
                return 2;
            }
            /**
             * 任职时间《3年 不合格
             */
            String postDates[] = talentDetail.getcPostDate().split(",");
            int ts = 0;
            for(String s:postDates){
                ts += Integer.valueOf(s);
            }
            if(ts<3){
                return 2;
            }

            if(talentDetail.getcRevenueT1()>=5000&&talentDetail.getcRevenueT2()>=5000&&talentDetail.getcRevenueT3()>=5000&&
                    "Y".equals(talentDetail.getcPostIs())
            ){
                /**
                 * 如果为其他正职，人工审核。否则合格
                 */
                if("5".equals(talentDetail.getcPost())){
                    return 3;
                }
                return 1;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return 2;
    }

    /**
     * NO.4		A：是否为“独角兽”选项	选“是”		达标
     * 			选“否”		此项无效
     * 		B：企业成立年月选项	截至填报时的企业成立时间	≤10年	达标
     * 				>10年	不达标
     * 		C：估值选项	按美元计价的估值	>10亿美元	达标
     * 				≤10亿美元	不达标
     * 		D：是否自然人股东选项	选“是”		达标
     * 			选“否”		此项无效
     * 		E：持股比例选项	≥5%		达标
     * 			<5%		不达标
     * 		F：公司内部排名选项	第一名		达标
     * 			第二名		达标
     * 			第三名		达标
     * 			其他名次		不达标
     * @param talentDetail
     * @return
     */
    public Boolean checkD(TalentDetail talentDetail){
        int year = DateUtils.getDateYearPoor(talentDetail.getdEstablishedDate(),DateUtils.getNowDate());
        try{
            if("Y".equals(talentDetail.getdIs())&&
                    year<=10&&talentDetail.getdEvaluation()>10&&
                    "Y".equals(talentDetail.getdIsShareholder())&&
                    talentDetail.getdProportion()>5&&
                    talentDetail.getdNumber()<=3
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }
    /*public Boolean checkE(TalentDetail talentDetail){
        return true;
    }*/

    /**
     * 审核规则：
     * 1.自主投入数额超过0.5亿元的，合格；
     * 2.获得股权类现金融资超过0.7亿元的，合格；
     * 3.申请人持股比例大于等于5%的，合格；
     * 4.申请人持股比例列前3倍的，合格。
     *
     * 1、2、3、4均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param talentDetail
     * @return
     */
    public Boolean checkF(TalentDetail talentDetail){
        try{
            if("Y".equals(talentDetail.getfIs())&&
                    "Y".equals(talentDetail.getfIsPartner())&&
                    talentDetail.getfInvestment()>=5000&&
                    talentDetail.getfFinancing()>=7000&&
                    talentDetail.getfShareholdingRatio()>=5&&
                    talentDetail.getfRatioNo()<=3
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：
     * 1.基金管理人和所管理基金设立、备案地为北京市大兴区的，合格。
     * 2.实收资本超过10亿元的（不含10亿元），合格；
     * 3.实际投资本市相关产业资金超过5亿元的（不含5亿元），合格；
     * 4.任职满3年的，合格；
     * 5.申请人职务为法定代表人、总经理、合伙人、合伙人委派代表的，合格。选择“其他”的，不合格。
     *
     * 1、2、3、4、5均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param talentDetail
     * @return
     */
    public Integer checkG(TalentDetail talentDetail){
        int year = DateUtils.getDateYearPoor(talentDetail.getgPostDate(),DateUtils.getNowDate());
        /**
         * 2.19
         * 备案地非北京市的不合格
         * 职务为中层及以下管理人员的不合格
         */
        try{
            if("3".equals(talentDetail.getgPlaceFundBa())||"3".equals(talentDetail.getgPlaceManageBa())||"3".equals(talentDetail.getgPlaceFundSl())||"3".equals(talentDetail.getgPlaceManageSl())||StringUtils.isEmpty(talentDetail.getgPost())||"6".equals(talentDetail.getgPost())){
                return 2;
            }
            if("Y".equals(talentDetail.getgIs())&&
                    talentDetail.getgCapital()>=10&&
                    talentDetail.getgCapitalTotal()>=5&&
                    year>=10){
                if("5".equals(talentDetail.getgPost())){
                    return 3;
                }
                return 1;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return 2;
    }

    /**
     * 审核规则：
     * 1.申请人所在单位2018年度市级财政贡献5000万元以上的，合格；
     * 2.申请人所在单位2019年度市级财政贡献5000万元以上的，合格；
     * 3.申请人所在单位2020年度市级财政贡献5000万元以上的，合格；
     * 4.申请人在京应税收入超过530万元的，合格。
     *
     * 1、2、3、4均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param baseInfo
     * @return
     */
    public Boolean checkH(TalentBaseInfo baseInfo){
        TalentDetail talentDetail = baseInfo.getTalentDetail();
        try{
            if("Y".equals(talentDetail.gethIs())&&
                    talentDetail.gethCompanyT1()>=5000&&
                    talentDetail.gethCompanyT2()>=5000&&
                    talentDetail.gethCompanyT3()>=5000&&
                    baseInfo.getEarningsT3()>=530&&
                    baseInfo.getEarningsT2()>=530&&
                    baseInfo.getEarningsT1()>=530
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：
     * 1.平台名称准确无误的，合格；
     * 2.2018年在京应税收入达到42万的，合格；
     * 3.2019年在京应税收入达到42万的，合格；
     * 4.2020年在京应税收入达到42万的，合格；
     * 5.职务为高级管理人才或技术研发骨干的，合格。
     *
     * 本项存在人工审核项目，首先显示Ⅲ。人工审核后，1、2、3、4、5均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param baseInfo
     * @return
     */
    public Integer checkI(TalentBaseInfo baseInfo){
        try{
            if( baseInfo.getEarningsT3()>=43&&
                    baseInfo.getEarningsT2()>=43&&
                    baseInfo.getEarningsT1()>=43
            ){
                return 3;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return 1;
    }

    /**
     * 审核规则：
     * 1.2018年公司年度市级财政贡献超过1000万元的，合格；
     * 2.2019年公司年度市级财政贡献超过1000万元的，合格；
     * 3.2020年公司年度市级财政贡献超过1000万元的，合格；
     * 4.申请人职务为平台架构师、算法工程师、产业平台规划师、产品工程师、技术经纪人的，合格；选择“其他”的，不合格。
     * 5.申请人2018年在京应税收入超过43万的，合格；
     * 6.申请人2019年在京应税收入超过43万的，合格；
     * 7.申请人2020年在京应税收入超过43万的，合格。
     *
     * 1、2、3、4、5、6、7项均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param baseInfo
     * @return
     */
    public Integer checkJ(TalentBaseInfo baseInfo){
        TalentDetail talentDetail = baseInfo.getTalentDetail();
        try{
            if("Y".equals(talentDetail.getjIs())&&
                    talentDetail.getjCompanyT1()>=1000&&
                    talentDetail.getjCompanyT2()>=1000&&
                    talentDetail.getjCompanyT3()>=1000&&
                    baseInfo.getEarningsT1()>=43&&
                    baseInfo.getEarningsT2()>=43&&
                    baseInfo.getEarningsT3()>=43&&
                    StringUtils.isNotEmpty(talentDetail.getjPost())
            ){
                if("6".equals(talentDetail.getjPost())){
                    return 3;
                }
                return 1;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return 2;
    }

    /**
     * 审核规则：
     * 1.2018年公司年度市级财政贡献超过500万元的，合格；
     * 2.2019年公司年度市级财政贡献超过500万元的，合格；
     * 3.2020年公司年度市级财政贡献超过500万元的，合格；
     * 4.在本单位工作满5年的，合格；
     * 5.申请人2016年在京应税收入超过43万的，合格
     * 6.申请人2017年在京应税收入超过43万的，合格
     * 7.申请人2018年在京应税收入超过43万的，合格；
     * 8.申请人2019年在京应税收入超过43万的，合格；
     * 9.申请人2020年在京应税收入超过43万的，合格。
     *
     * 1、2、3、4、5、6、7、8、9项均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param baseInfo
     * @return
     */
    public Boolean checkK(TalentBaseInfo baseInfo){
        TalentDetail talentDetail = baseInfo.getTalentDetail();
        try{
            int year = DateUtils.getDateYearPoor(talentDetail.getkHiredate(),DateUtils.getNowDate());
            if("Y".equals(talentDetail.getkIs())&&
                    talentDetail.getkCompanyT1()>=500&&
                    talentDetail.getkCompanyT2()>=500&&
                    talentDetail.getkCompanyT3()>=500&&
                    baseInfo.getEarningsT1()>=43&&
                    baseInfo.getEarningsT2()>=43&&
                    baseInfo.getEarningsT3()>=43&&
                   // talentDetail.getkEarningsT4()>=43&&
                   // talentDetail.getkEarningsT5()>=43&&
                    year>=5
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：
     * 1.申请人所在单位是高新技术企业、创新型总部企业、新型研发机构等科技创新主体，合格；
     * 2.申请人2018年在京应税收入超过62万的，合格；
     * 3.申请人2019年在京应税收入超过62万的，合格；
     * 4.申请人2020年在京应税收入超过62万的，合格。
     * 5.申请人职务为技术性职务的，不含后勤人员，合格。
     *
     * 1、2、3、4、5项均合格，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     *
     *
     * 2.19
     * 对应基础表中的应税收入
     * @param baseInfo
     * @return
     */
    public Boolean checkL(TalentBaseInfo baseInfo){
        TalentDetail talentDetail = baseInfo.getTalentDetail();
        try{
            if(baseInfo.getEarningsT1()>=61&&
                    baseInfo.getEarningsT2()>=61&&
                    baseInfo.getEarningsT3()>=61
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：
     * 1.申请人所在单位是知识产权服务机构、金融机构、人力资源服务机构或律师、会计师、审计师事务所等科技创新服务主体，合格；
     * 2.申请人2018年在京应税收入超过159万的，合格；
     * 3.申请人2019年在京应税收入超过159万的，合格；
     * 4.申请人2020年在京应税收入超过159万的，合格。
     *
     * 1、2、3、4项均合格，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param baseInfo
     * @return
     */
    public Boolean checkM(TalentBaseInfo baseInfo){
        TalentDetail talentDetail = baseInfo.getTalentDetail();
        try{
            if("Y".equals(talentDetail.getmIs())&&
                    baseInfo.getEarningsT1()>=159&&
                    baseInfo.getEarningsT2()>=159&&
                    baseInfo.getEarningsT3()>=159
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：
     * 1.申请人从事电子商务、网络直播、电子竞技、数字媒体等领域工作，合格；
     * 2.申请人2018年在京应税收入超过530万的，合格；
     * 3.申请人2019年在京应税收入超过530万的，合格；
     * 4.申请人2020年在京应税收入超过530万的，合格。
     *
     * 1、2、3、4项均合格，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param baseInfo
     * @return
     */
    public Boolean checkN(TalentBaseInfo baseInfo){
        TalentDetail talentDetail = baseInfo.getTalentDetail();
        try{
            if("Y".equals(talentDetail.getnIs())&&
                    baseInfo.getEarningsT1()>=530&&
                    baseInfo.getEarningsT2()>=530&&
                    baseInfo.getEarningsT3()>=530
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：
     * 1.向申请人所在单位投资的政府产业引导基金及其他投资机构名称真实有效，合格；
     * 2.2018-2020年投资总额超过1000万元，合格；
     * 3.引进人才是主要创始人或核心合伙人的，合格；
     *
     * 1、2、3项均合格，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     *
     *
     * 2.19
     * NO.14		A：是否选项	选“是”		达标		合格	A、B、C内所有项目均达标；或者A、C、D内所有项目均达标。
     * 			选“否”		此项无效
     * 		B：政府产业引导基金情况	名称		达标
     * 			近三年投资总额	≥1000万元	达标
     * 				<1000万元	不达标
     * 		C：其他股权类现金投资情况	名称		达标		不合格	A、B、C、D选项显示1个或多个“不达标”的。
     * 			近三年投资总额	≥1000万元	达标
     * 				<1000万元	不达标
     * 		D：引进人才身份	主要创始人或核心合伙人		达标
     * 			其他身份		不达标		无效	A选项显示“此项无效”的。
     *
     * @param talentDetail
     * @return
     */
    public Boolean checkO(TalentDetail talentDetail){
        try{
            if("Y".equals(talentDetail.getoIs())&&
                    StringUtils.isNotEmpty(talentDetail.getoOrgName())&&
                    talentDetail.getoOrgInvestment()>=1000&&
                    "Y".equals(talentDetail.getoIsPartner())
            ){
                return true;
            }
            if("Y".equals(talentDetail.getoIs())&&
                    StringUtils.isNotEmpty(talentDetail.getoGovernmentName())&&
                    talentDetail.getoGovernmentInvestment()>=1000&&
                    StringUtils.isNotEmpty(talentDetail.getoOrgName())&&
                    talentDetail.getoOrgInvestment()>=1000
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：
     * 1.2018-2020年累计自主投资总额超过1亿元的，合格；
     * 2.2018-2020年累计获得股权类现金融资总额超过1.5亿元的，合格；
     * 3.推荐人1姓名完整的，合格；
     * 4.推荐人2姓名完整的，合格。
     *
     * 1、3、4均合格的，本项合格，显示Ⅰ；或者，2、3、4项均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param talentDetail
     * @return
     */
    public Boolean checkP(TalentDetail talentDetail){
        try{
            if((talentDetail.getpInvestmentTotal()>=10000||talentDetail.getpFinancingTotal()>=15000)
                    &&StringUtils.isNotEmpty(talentDetail.getpNameOne())
                    &&StringUtils.isNotEmpty(talentDetail.getpNameTwo())
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：
     * 1.获奖年度填写格式正确的，合格；
     * 2.举办单位填写完整的，合格 （需人工审核）；
     * 3.填写完整的，合格；
     * 4.获投资年度填写格式正确的，合格；
     * 5.数字填写正确，且超过1000万元的，合格；
     * 6.申请人是主要创始人或核心合伙人的，合格。
     *
     * 本项存在人工审核项目，首先显示Ⅲ。人工审核后，1、2、3、4、5、6项均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param talentDetail
     * @return
     */
    public Integer checkQ(TalentDetail talentDetail){
        try{
            if(StringUtils.isEmpty(talentDetail.getqOrg())||"N".equals(talentDetail.getqIsPartner())||talentDetail.getqInvestmentTotal()<=1000||(talentDetail.getqInvestmentYear()-talentDetail.getqAwardsYear())>1){
                return 2;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return 3;
    }

    /**
     * 审核规则：
     * 1.选择北京市大兴区的，合格；
     * 2.数量大于1亿元的，合格；
     * 3.数量大于0.5亿元的，合格；
     * 4.职务为法定代表人、总经理、合伙人、合伙人委派代表的，合格；选择“其他”的，不合格。
     * 5.任职时间至申报时满3年的，合格。
     *
     * 1、2、3、4、5均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param talentDetail
     * @return
     */
    public Integer checkR(TalentDetail talentDetail){
        /**
         * 非北京市的不合格
         */
        try{
            if("3".equals(talentDetail.getrPlaceFundBa())||"3".equals(talentDetail.getrPlaceManageBa())||"3".equals(talentDetail.getrPlaceFundSl())||"3".equals(talentDetail.getrPlaceManageSl())||StringUtils.isEmpty(talentDetail.getrPost())){
                return 2;
            }
            if("2".equals(talentDetail.getrType())){
                return checkS(talentDetail);
            }
            int year = DateUtils.getDateYearPoor(talentDetail.getrWorkDate(),DateUtils.getNowDate());
            if("Y".equals(talentDetail.getrIs())&&
                    talentDetail.getrAsset()>10000&&
                    talentDetail.getrNvestmentTotal()>5000&&
                    year>=3
            ){
                if("5".equals(talentDetail.getrPost())){
                    return 3;
                }
                return 1;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return 2;
    }

    /**
     * 审核规则：
     * 1.选择北京市大兴区的，合格；
     * 2.数量大于3亿元的，合格；
     * 3.数量大于5亿元的，合格；
     * 4.职务为法定代表人、总经理、合伙人、合伙人委派代表的，合格；选择“其他”的，不合格。
     * 5.任职时间至申报时满3年的，合格。
     *
     * 1、2、3、4、5均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param talentDetail
     * @return
     */
    public Integer checkS(TalentDetail talentDetail){
        try{
            int year = DateUtils.getDateYearPoor(talentDetail.getrWorkDate(),DateUtils.getNowDate());
            if("Y".equals(talentDetail.getrIs())&&
                    talentDetail.getrAsset()>30000&&
                    talentDetail.getrNvestmentTotal()>50000&&
                    year>=3
            ){
                if("5".equals(talentDetail.getrPost())){
                    return 3;
                }
                return 1;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return 2;
    }

    /**
     * 审核规则：
     * C：大学	基本信息	C1:国内一流学科	达标
     * 		C2:世界大学排名前200的STEM专业的	达标
     * 		C3:世界大学排名前300的	不达标
     * 	所获学位	C4:大学本科	达标
     * 	年龄	C5:≤40周岁	达标
     * 	回国或毕业时间	C6:≤3年	达标
     * 	签订劳动合同年限	C7:≤3年	达标
     * 	在该单位已经工作时间	C8:≤2年	达标
     * D：硕士	基本信息	D1:国内一流学科	达标
     * 		D2:世界大学排名前200的STEM专业的	达标
     * 		D3:世界大学排名前300的	达标
     * 	所获学位	D4:硕士学位	达标
     * 	毕业时间	D5:≥2年	达标
     *
     *
     * @param talentBaseInfo
     * @return
     */
    public Boolean checkT(TalentBaseInfo talentBaseInfo){
        try{
            /**
             * 硕士及以上学历 合格
             */
            if("2".equals(talentBaseInfo.getMasterDegree())||"3".equals(talentBaseInfo.getPhdDegree())){
                return true;
            }
            if(talentBaseInfo.getBirthday()==null||talentBaseInfo.getHiredate()==null||talentBaseInfo.getuGraduationTime()==null){
                return false;
            }
            //年龄
            int old = DateUtils.getDateYearPoor(talentBaseInfo.getBirthday(),DateUtils.getNowDate());
            //入职时间
            int hire = DateUtils.getDateYearPoor(talentBaseInfo.getHiredate(),DateUtils.getNowDate());
            //本科毕业时间
            int graduation = DateUtils.getDateYearPoor(talentBaseInfo.getuGraduationTime(),DateUtils.getNowDate());
            if(talentBaseInfo.getSchoolNumber()<=200
                    &&"1".equals(talentBaseInfo.getuDegree())
                    &&old<=40&&hire<=3&&graduation<=2
                    &&talentBaseInfo.getContractLong()<=3){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }

        return false;
    }

    /**
     * 审核规则：
     * 1.直接调取表1数据，有相应信息的，合格；
     * 2.直接调取表1数据，有相应信息的，合格；
     * 3.有高级专业技术职称的，合格；
     * 4.发证单位填写完整的，合格。
     *
     * 1、2均合格的，本项合格，显示Ⅰ；3、4均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param baseInfo
     * @return
     */
    public Boolean checkU(TalentBaseInfo baseInfo){
        try{
            if("1".equals(baseInfo.getSenior())||"2".equals(baseInfo.getSenior())
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：（此项目需结合人工审核）
     * 1.姓名填写完整的，合格。
     * 2.称号为国家级、京内重大人才工程的，合格；
     * 3.评审单位为国家级、北京市级机关单位的，合格；
     * 4.姓名填写完整的，合格。
     * 5.称号为国家级、京内重大人才工程的，合格；
     * 6.评审单位为国家级、北京市级机关单位的，合格。
     *
     * 本项存在人工审核项目，首先显示Ⅲ。人工审核后，1、2、3、4、5、6项全部合格，则本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param talentDetail
     * @return
     */
    /*public Boolean checkV(TalentDetail talentDetail){
        return true;
    }*/

    /**
     * 审核规则：
     * 1.曾获“中国专利金奖”的，合格；
     * 2.以独立完成身份获得发明专利数量超过2个，合格；
     * 3.相关专利均有号码，合格；
     * 4.以第二作者及以上身份获得发明专利数量超过5个，合格；
     * 5，相关专利均有号码，合格；
     *
     * 1、2、3项均合格的，本项合格，显示Ⅰ；1、4、5项均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param talentDetail
     * @return
     */
    public Boolean checkW(TalentDetail talentDetail){
        try{
            String firstNo = talentDetail.getwPatentNumber()!=null?talentDetail.getwPatentNumber():"";
            String secondNo = talentDetail.getwSecondPatentNumber()!=null?talentDetail.getwSecondPatentNumber():"";
            if("Y".equals(talentDetail.getwIs())){
                return true;
            }
            if(talentDetail.getwFirstCount()>=3&&talentDetail.getwFirstCount() == firstNo.split(",").length
            ){
                return true;
            }
            if(talentDetail.getwSecondCount()>=6&&talentDetail.getwSecondCount() == secondNo.split(",").length
            ){
                return true;
            }
        }catch ( Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 审核规则：（此项目需结合人工审核）
     * 1.颁发单位为京内局级机关、国有企业、事业单位的，合格；
     * 2.项目名称完整、真实的，合格；
     * 3.入选时间格式正确的，合格。
     *
     * 本项存在人工审核项目，首先显示Ⅲ。人工审核后，1、2、3项均合格的，本项合格，显示Ⅰ。任意项不合格的，本项不合格，显示Ⅱ。
     * @param talentDetail
     * @return
     */
    /*public Boolean checkX(TalentDetail talentDetail){
        return true;
    }*/
}
